use warp::Filter;
use std::path::PathBuf;
use log::{info, error};
use super::html_templates;
use urlencoding::encode;

/// 启动HTTP服务器（简化版，重定向到移动端绘图页面）
pub async fn start_http_server(port: u16) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    info!("启动HTTP服务器，端口: {}", port);

    // 创建根路径路由，返回重定向到移动端绘图页面的HTML
    let index_route = warp::path::end().and(warp::query::raw()).map(|query: String| {
            let redirect_url = if query.is_empty() {
                "/#/drawguess".to_string()
            } else {
                log::info!("Raw query string: {}", query);
                // 清理查询字符串：移除开头的?字符（如果有）
                let clean_query = if query.starts_with('?') {
                    query[1..].to_string()
                } else {
                    query.clone()
                };
                log::info!("Cleaned query string: {}", clean_query);

                // 解析并重新编码查询字符串，确保所有参数正确编码
                let processed_query = {
                    use url::form_urlencoded;

                    let decoded_pairs: Vec<(String, String)> = form_urlencoded::parse(clean_query.as_bytes())
                        .map(|(k, v)| (k.into_owned(), v.into_owned()))
                        .collect();

                    let reencoded = form_urlencoded::Serializer::new(String::new())
                        .extend_pairs(decoded_pairs.iter())
                        .finish();

                    log::info!("Re-encoded query string: {}", reencoded);
                    reencoded
                };
                format!("/?{}#/drawguess", processed_query)
            };
        
        warp::reply::html(html_templates::mobile_redirect_html(&redirect_url))
    });

    // 启动服务器
    let addr = std::net::SocketAddr::from(([0, 0, 0, 0], port));
    info!("HTTP服务器启动在 http://0.0.0.0:{}", port);
    
    // 检查端口是否可用
    if let Err(e) = std::net::TcpListener::bind(addr) {
        error!("HTTP服务器绑定端口 {} 失败: {}", port, e);
        return Err(format!("端口 {} 被占用或无法绑定: {}", port, e).into());
    }
    
    info!("HTTP服务器成功绑定到端口 {}", port);
    warp::serve(index_route)
        .run(addr)
        .await;

    Ok(())
}

/// HTTP服务器模块，用于投射静态资源
pub struct HttpServer {
    port: u16,
    static_dir: PathBuf,
}

impl HttpServer {
    /// 创建新的HTTP服务器实例
    pub fn new(port: u16, static_dir: PathBuf) -> Self {
        Self {
            port,
            static_dir,
        }
    }

    /// 启动HTTP服务器
    pub async fn start(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        info!("启动HTTP服务器，端口: {}, 静态资源目录: {:?}", self.port, self.static_dir);

        // 检查静态资源目录是否存在
        if !self.static_dir.exists() {
            error!("静态资源目录不存在: {:?}", self.static_dir);
            return Err(format!("静态资源目录不存在: {:?}", self.static_dir).into());
        }

        // 创建静态文件服务路由
        let static_files = warp::fs::dir(self.static_dir.clone());

        // 创建根路径重定向到绘图页面的路由
        let draw_route = warp::path::end()
            .and(warp::query::raw())
            .map(|query: String| {
                let redirect_url = if query.is_empty() {
                    "/#/drawguess".to_string()
                } else {
                    // 清理查询字符串：移除开头的?字符（如果有）
                    let clean_query = if query.starts_with('?') {
                        query[1..].to_string()
                    } else {
                        query
                    };
                    
                    // 解析并重新编码查询字符串，确保所有参数正确编码
                    let processed_query = {
                        use url::form_urlencoded;

                        let decoded_pairs: Vec<(String, String)> = form_urlencoded::parse(clean_query.as_bytes())
                            .map(|(k, v)| (k.into_owned(), v.into_owned()))
                            .collect();

                        let reencoded = form_urlencoded::Serializer::new(String::new())
                            .extend_pairs(decoded_pairs.iter())
                            .finish();

                        reencoded
                    };
                    format!("/?{}#/drawguess", processed_query)
                };
                warp::reply::html(html_templates::mobile_redirect_html(&redirect_url))
            });

        // 组合路由
        let routes = draw_route.or(static_files);

        // 启动服务器
        let addr = std::net::SocketAddr::from(([0, 0, 0, 0], self.port));
        info!("HTTP服务器启动在 http://0.0.0.0:{}", self.port);
        
        // 检查端口是否可用
        if let Err(e) = std::net::TcpListener::bind(addr) {
            error!("HTTP服务器绑定端口 {} 失败: {}", self.port, e);
            return Err(format!("端口 {} 被占用或无法绑定: {}", self.port, e).into());
        }
        
        info!("HTTP服务器成功绑定到端口 {}", self.port);
        warp::serve(routes)
            .run(addr)
            .await;

        Ok(())
    }
}
